Section 0 问题描述与完成项目流程

1. 问题描述

在该项目中，你将使用强化学习算法，实现一个自动走迷宫机器人。

1. 如上图所示，智能机器人显示在右上角。在我们的迷宫中，有陷阱（红色炸弹）及终点（蓝色的目标点）两种情景。机器人要尽量避开陷阱、尽快到达目的地。
2. 小车可执行的动作包括：向上走 u、向右走 r、向下走 d、向左走 l。
3. 执行不同的动作后，根据不同的情况会获得不同的奖励，具体而言，有以下几种情况。
   • 撞到墙壁：-10
   • 走到终点：50
   • 走到陷阱：-30
   • 其余情况：-0.1
4. 我们需要通过修改 robot.py 中的代码，来实现一个 Q Learning 机器人，实现上述的目标。

2. 完成项目流程

1. 配置环境，使用 envirnment.yml 文件配置名为 robot-env 的 conda 环境，具体而言，你只需转到当前的目录，在命令行/终端中运行如下代码，稍作等待即可。

   conda env create -f envirnment.yml

   安装完毕后，在命令行/终端中运行 source activate robot-env（Mac/Linux 系统）或 activate robot-env（Windows 系统）激活该环境。

2. 阅读 main.ipynb 中的指导完成项目，并根据指导修改对应的代码，生成、观察结果。

3. 导出代码与报告，上传文件，提交审阅并优化。

---

---

Section 1 算法理解

1. 1 强化学习总览

强化学习作为机器学习算法的一种，其模式也是让智能体在“训练”中学到“经验”，以实现给定的任务。但不同于监督学习与非监督学习，在强化学习的框架中，我们更侧重通过智能体与环境的交互来学习。通常在监督学习和非监督学习任务中，智能体往往需要通过给定的训练集，辅之以既定的训练目标（如最小化损失函数），通过给定的学习算法来实现这一目标。然而在强化学习中，智能体则是通过其与环境交互得到的奖励进行学习。这个环境可以是虚拟的（如虚拟的迷宫），也可以是真实的（自动驾驶汽车在真实道路上收集数据）。

在强化学习中有五个核心组成部分，它们分别是：环境（Environment）、智能体（Agent）、状态（State）、动作（Action）和奖励（Reward）。在某一时间节点 $t$：

• 智能体在从环境中感知其所处的状态 $s_t$
• 智能体根据某些准则选择动作 $a_t$
• 环境根据智能体选择的动作，向智能体反馈奖励 $r_{t+1}$

通过合理的学习算法，智能体将在这样的问题设置下，成功学到一个在状态 $s_t$ 选择动作 $a_t$ 的策略 $\pi (s_t) = a_t$。

---

问题 1：请参照如上的定义，描述出 “机器人走迷宫这个问题” 中强化学习五个组成部分对应的实际对象：

• 环境 : 迷宫地图，具体包括：墙壁、终点、陷阱、其它（空白）
• 智能体 : 机器人
• 状态 : 在迷宫中的坐标
• 动作 : 移动方向（上、下、左、右）
• 奖励 : 环境的反馈（撞墙、终点、陷阱、正常）

$$T(s^{'}, a, s) = P(s^{'}|a,s)$$

---

1.2 计算 Q 值

在我们的项目中，我们要实现基于 Q-Learning 的强化学习算法。Q-Learning 是一个值迭代（Value Iteration）算法。与策略迭代（Policy Iteration）算法不同，值迭代算法会计算每个”状态“或是”状态-动作“的值（Value）或是效用（Utility），然后在执行动作的时候，会设法最大化这个值。因此，对每个状态值的准确估计，是我们值迭代算法的核心。通常我们会考虑最大化动作的长期奖励，即不仅考虑当前动作带来的奖励，还会考虑动作长远的奖励。

在 Q-Learning 算法中，我们把这个长期奖励记为 Q 值，我们会考虑每个 ”状态-动作“ 的 Q 值，具体而言，它的计算公式为：

$$ q(s_{t},a) = R_{t+1} + \gamma \times\max_a q(a,s_{t+1}) $$

也就是对于当前的“状态-动作” $(s_{t},a)$，我们考虑执行动作 $a$ 后环境给我们的奖励 $R_{t+1}$，以及执行动作 $a$ 到达 $s_{t+1}$后，执行任意动作能够获得的最大的Q值 $\max_a q(a,s_{t+1})$，$\gamma$ 为折扣因子。

不过一般地，我们使用更为保守地更新 Q 表的方法，即引入松弛变量 $alpha$，按如下的公式进行更新，使得 Q 表的迭代变化更为平缓。

$$ q(s_{t},a) = (1-\alpha) \times q(s_{t},a) + \alpha \times(R_{t+1} + \gamma \times\max_a q(a,s_{t+1})) $$

---

问题 2：根据已知条件求 $q(s_{t},a)$，在如下模板代码中的空格填入对应的数字即可。

已知：如上图，机器人位于 $s_1$，行动为 u，行动获得的奖励与题目的默认设置相同。在 $s_2$ 中执行各动作的 Q 值为：u: -24，r: -13，d: -0.29、l: +40，$\gamma$ 取0.9。

$$ \begin{align} q(s_{t},a) & = R_{t+1} + \gamma \times\max_a q(a,s_{t+1}) \\ & =(-0.1) + (0.9)*(40) \\ & =(35.9) \end{align} $$

---

1.3 如何选择动作

在强化学习中，「探索-利用」问题是非常重要的问题。具体来说，根据上面的定义，我们会尽可能地让机器人在每次选择最优的决策，来最大化长期奖励。但是这样做有如下的弊端：

1. 在初步的学习中，我们的 Q 值会不准确，如果在这个时候都按照 Q 值来选择，那么会造成错误。
2. 学习一段时间后，机器人的路线会相对固定，则机器人无法对环境进行有效的探索。

因此我们需要一种办法，来解决如上的问题，增加机器人的探索。由此我们考虑使用 epsilon-greedy 算法，即在小车选择动作的时候，以一部分的概率随机选择动作，以一部分的概率按照最优的 Q 值选择动作。同时，这个选择随机动作的概率应当随着训练的过程逐步减小。

---

问题 3：在如下的代码块中，实现 epsilon-greedy 算法的逻辑，并运行测试代码。

import random

actions = ['u','r','d','l']
qline = {'u':1.2, 'r':-2.1, 'd':-24.5, 'l':27}
epsilon = 0.3 # 以0.3的概率进行随机选择

def choose_action(epsilon):
    
    action = None
    if random()< epsilon: # 以某一概率
        action = random.choice(actions) # 实现对动作的随机选择
        
    else: 
        action = max(qline, key=qline.get) # 否则选择具有最大 Q 值的动作
        
    return action

---

---

Section 2 代码实现

2.1. Maze 类理解

我们首先引入了迷宫类 Maze，这是一个非常强大的函数，它能够根据你的要求随机创建一个迷宫，或者根据指定的文件，读入一个迷宫地图信息。

1. 使用 Maze("file_name") 根据指定文件创建迷宫，或者使用 Maze(maze_size=(height,width)) 来随机生成一个迷宫。
2. 使用 trap_number 参数，在创建迷宫的时候，设定迷宫中陷阱的数量。
3. 直接键入迷宫变量的名字按回车，展示迷宫图像（如 g=Maze("xx.txt")，那么直接输入 g 即可。
4. 建议生成的迷宫尺寸，长在 6~12 之间，宽在 10～12 之间。

---

问题 4：在如下的代码块中，创建你的迷宫并展示。

from Maze import Maze
%matplotlib inline
%config InlineBackend.figure_format = 'retina'

## todo: 创建迷宫并展示
mz = Maze(maze_size=(10,10), trap_number=3)
mz

D:\Learning\Udacity\Reinforcement_Learning\8. Proj_Maze_Q-learning走迷宫\MLND_CN_P5_Reinforcement_Learning-master\Maze.py:163: FutureWarning: arrays to stack must be passed as a "sequence" type such as list or tuple. Support for non-sequence iterables such as generators is deprecated as of NumPy 1.16 and will raise an error in the future.
  maze = np.vstack((np.hstack((grid_images[i] for i in row)) for row in self.maze_data))

Maze of size (10, 10)

---

你可能已经注意到，在迷宫中我们已经默认放置了一个机器人。实际上，我们为迷宫配置了相应的 API，来帮助机器人的移动与感知。其中你随后会使用的两个 API 为 maze.sense_robot() 及 maze.move_robot()。

1. maze.sense_robot() 为一个无参数的函数，输出机器人在迷宫中目前的位置。
2. maze.move_robot(direction) 对输入的移动方向，移动机器人，并返回对应动作的奖励值。

---

问题 5：随机移动机器人，并记录下获得的奖励，展示出机器人最后的位置。

rewards = []

## 循环、随机移动机器人10次，记录下奖励
for i in range(10):
    reward = mz.move_robot(random.choice(actions))
    rewards.append(reward)
## 输出机器人最后的位置
print(mz.sense_robot())

## 打印迷宫，观察机器人位置
mz

(0, 8)

Maze of size (10, 10)

2.2. Robot 类实现

Robot 类是我们需要重点实现的部分。在这个类中，我们需要实现诸多功能，以使得我们成功实现一个强化学习智能体。总体来说，之前我们是人为地在环境中移动了机器人，但是现在通过实现 Robot 这个类，机器人将会自己移动。通过实现学习函数，Robot 类将会学习到如何选择最优的动作，并且更新强化学习中对应的参数。

首先 Robot 有多个输入，其中 alpha=0.5, gamma=0.9, epsilon0=0.5 表征强化学习相关的各个参数的默认值，这些在之前你已经了解到，Maze 应为机器人所在迷宫对象。

随后观察 Robot.update 函数，它指明了在每次执行动作时，Robot 需要执行的程序。按照这些程序，各个函数的功能也就明了了。

最后你需要实现 Robot.py 代码中的8段代码，他们都在代码中以 #TODO 进行标注，你能轻松地找到他们。

---

问题 6：实现 Robot.py 中的8段代码，并运行如下代码检查效果（记得将 maze 变量修改为你创建迷宫的变量名）。

from Robot import Robot
robot = Robot(mz) # 记得将 maze 变量修改为你创建迷宫的变量名
robot.set_status(learning=True,testing=False)
print(robot.update())

mz

('r', -0.1)

Maze of size (10, 10)

---

2.3 用 Runner 类训练 Robot

在实现了上述内容之后，我们就可以开始对我们 Robot 进行训练并调参了。我们为你准备了又一个非常棒的类 Runner，来实现整个训练过程及可视化。使用如下的代码，你可以成功对机器人进行训练。并且你会在当前文件夹中生成一个名为 filename 的视频，记录了整个训练的过程。通过观察该视频，你能够发现训练过程中的问题，并且优化你的代码及参数。

---

问题 7：尝试利用下列代码训练机器人，并进行调参。可选的参数包括：

• 训练参数
  • 训练次数 epoch
• 机器人参数：
  • epsilon0 (epsilon 初值)
  • epsilon衰减（可以是线性、指数衰减，可以调整衰减的速度），你需要在 Robot.py 中调整
  • alpha
  • gamma
• 迷宫参数:
  • 迷宫大小
  • 迷宫中陷阱的数量

## 可选的参数：
epoch =150

epsilon0 = 1 ## 平衡探索与利用（实际运行时epsilon的初值）
alpha = 0.5 ## 平衡加权已有经验和最新经验（alpha代表最新经验权重）
gamma = 0.9 ## 每个epoch中后续状态值对当前状态值的影响程度

maze_size = (8,8)
trap_number = 4

from Runner import Runner

g = Maze(maze_size=maze_size,trap_number=trap_number)
g

Maze of size (8, 8)

g1 = Maze(maze_size=maze_size,trap_number=trap_number)
g1

Maze of size (8, 8)

g2 = Maze(maze_size=maze_size,trap_number=trap_number)
g2

Maze of size (8, 8)

## 存在简单解的场景(g)

# 默认参数值
from Robot import Robot
r0 = Robot(g,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r0.set_status(learning=True,testing=False)
runner0 = Runner(r0, g)
runner0.run_training(epoch, display_direction=True)
runner0.plot_results()

## 倍数放大epsilon0 10倍
r1 = Robot(g,alpha=alpha, epsilon0=epsilon0*10, gamma=gamma)
r1.set_status(learning=True,testing=False)
runner1 = Runner(r1, g)
runner1.run_training(epoch, display_direction=True)
runner1.plot_results()

## 指数放大epsilon (epsilon = epsilon0/pow(t,0.63))
from Robot2 import Robot2
r2 = Robot2(g,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r2.set_status(learning=True,testing=False)
runner2 = Runner(r2, g)
runner2.run_training(epoch, display_direction=True)
runner2.plot_results()

## epsilon0 = 0
r3 = Robot(g,alpha=alpha, epsilon0=0, gamma=gamma)
r3.set_status(learning=True,testing=False)
runner3 = Runner(r3, g)
runner3.run_training(epoch, display_direction=True)
runner3.plot_results()

# 指数级缩小espison (epsilon = epsilon0/pow(t,5))
from Robot3 import Robot3
r4 = Robot3(g,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r4.set_status(learning=True,testing=False)
runner4 = Runner(r4, g)
runner4.run_training(epoch, display_direction=True)
runner4.plot_results() ## epsilon0 = 0

## 不存在简单解的场景(g1)

# 默认参数值
from Robot import Robot
r5 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r5.set_status(learning=True,testing=False)
runner5 = Runner(r5, g1)
runner5.run_training(epoch, display_direction=True)
runner5.plot_results()

## 倍数放大epsilon0 10倍
r6 = Robot(g1,alpha=alpha, epsilon0=epsilon0*10, gamma=gamma)
r6.set_status(learning=True,testing=False)
runner6 = Runner(r6, g1)
runner6.run_training(epoch, display_direction=True)
runner6.plot_results()

## 指数放大epsilon (epsilon = epsilon0/pow(t,0.63))
from Robot2 import Robot2
r7 = Robot2(g1,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r7.set_status(learning=True,testing=False)
runner7 = Runner(r7, g1)
runner7.run_training(epoch, display_direction=True)
runner7.plot_results()

## epsilon0 = 0
r8 = Robot(g1,alpha=alpha, epsilon0=0, gamma=gamma)
r8.set_status(learning=True,testing=False)
runner8 = Runner(r3, g1)
runner8.run_training(epoch, display_direction=True)
runner8.plot_results()

# 指数级缩小espison (epsilon = epsilon0/pow(t,5))
from Robot3 import Robot3
r9 = Robot3(g1,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r9.set_status(learning=True,testing=False)
runner9 = Runner(r9, g1)
runner9.run_training(epoch, display_direction=True)
runner9.plot_results() ## epsilon0 = 0

## 存在简单解的场景(g)

# 默认参数值
r10 = Robot(g,alpha=0.5, epsilon0=epsilon0, gamma=gamma)
r10.set_status(learning=True,testing=False)
runner10 = Runner(r10, g)
runner10.run_training(epoch, display_direction=True)
runner10.plot_results()

## alpha = 0.9
r11 = Robot(g,alpha=0.9, epsilon0=epsilon0, gamma=gamma)
r11.set_status(learning=True,testing=False)
runner11 = Runner(r11, g)
runner11.run_training(epoch, display_direction=True)
runner11.plot_results()

## alpha = 0.1
r12 = Robot(g,alpha=0.1, epsilon0=epsilon0, gamma=gamma)
r12.set_status(learning=True,testing=False)
runner12 = Runner(r12, g)
runner12.run_training(epoch, display_direction=True)
runner12.plot_results()

## 不存在简单解的场景(g1)

# 默认参数值
r13 = Robot(g1,alpha=alpha, epsilon0=epsilon0*2, gamma=gamma)
r13.set_status(learning=True,testing=False)
runner13 = Runner(r13, g1)
runner13.run_training(epoch, display_direction=True)
runner13.plot_results()

## alpha = 0.9
r14 = Robot(g1,alpha=0.9, epsilon0=epsilon0*2, gamma=gamma)
r14.set_status(learning=True,testing=False)
runner14 = Runner(r14, g1)
runner14.run_training(epoch, display_direction=True)
runner14.plot_results()

## alpha = 0.1
r15 = Robot(g1,alpha=0.1, epsilon0=epsilon0*2, gamma=gamma)
r15.set_status(learning=True,testing=False)
runner15 = Runner(r15, g1)
runner15.run_training(epoch*5, display_direction=True)
runner15.plot_results()

## 存在简单解的场景(g)

# 默认参数值
r20 = Robot(g,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r20.set_status(learning=True,testing=False)
runner20 = Runner(r20, g)
runner20.run_training(epoch, display_direction=True)
runner20.plot_results()

## gamma = 0.99
r21 = Robot(g,alpha=alpha, epsilon0=epsilon0, gamma=0.99)
r21.set_status(learning=True,testing=False)
runner21 = Runner(r21, g)
runner21.run_training(epoch, display_direction=True)
runner21.plot_results()

## gamma = 0.6
r22 = Robot(g,alpha=alpha, epsilon0=epsilon0, gamma=0.6)
r22.set_status(learning=True,testing=False)
runner22 = Runner(r22, g)
runner22.run_training(epoch, display_direction=True)
runner22.plot_results()

## 不存在简单解的场景(g1)

# 默认参数值
r23 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r23.set_status(learning=True,testing=False)
runner23 = Runner(r23, g1)
runner23.run_training(epoch, display_direction=True)
runner23.plot_results()

## gamma = 0.99
r24 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=0.99)
r24.set_status(learning=True,testing=False)
runner24 = Runner(r24, g1)
runner24.run_training(epoch, display_direction=True)
runner24.plot_results()

## gamma = 0.6
r25 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=0.6)
r25.set_status(learning=True,testing=False)
runner25 = Runner(r25, g1)
runner25.run_training(epoch, display_direction=True)
runner25.plot_results()

## 不存在简单解的场景(g1)

# 默认参数值，training_per_epoch = 150
r26 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r26.set_status(learning=True,testing=False)
runner26 = Runner(r26, g1)
runner26.run_training(epoch, display_direction=True)
runner26.plot_results()

## training_per_epoch = 300
r27 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=0.9)
r27.set_status(learning=True,testing=False)
runner27 = Runner(r27, g1)
runner27.run_training(epoch, training_per_epoch=300, display_direction=True)
runner27.plot_results()

## training_per_epoch = 500
r28 = Robot(g1,alpha=alpha, epsilon0=epsilon0, gamma=0.9)
r28.set_status(learning=True,testing=False)
runner28 = Runner(r28, g1)
runner28.run_training(epoch, training_per_epoch=500, display_direction=True)
runner28.plot_results()

## 存在特别困难解的场景(g2)

print('对于g2地图:')

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)):')
r30 = Robot2(g2,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r30.set_status(learning=True,testing=False)
runner30 = Runner(r30, g2)
runner30.run_training(epoch, display_direction=True)
runner30.plot_results()

print('alpha = 0.9:')
r31 = Robot(g2,alpha=0.9, epsilon0=epsilon0, gamma=gamma)
r31.set_status(learning=True,testing=False)
runner31 = Runner(r31, g2)
runner31.run_training(epoch, display_direction=True)
runner31.plot_results()

print('gamma = 0.99:')
r32 = Robot(g2,alpha=alpha, epsilon0=epsilon0, gamma=0.99)
r32.set_status(learning=True,testing=False)
runner32 = Runner(r32, g2)
runner32.run_training(epoch, display_direction=True)
runner32.plot_results()

print('training_per_epoch = 500:')
r33 = Robot(g2,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r33.set_status(learning=True,testing=False)
runner33 = Runner(r33, g2)
runner33.run_training(epoch, training_per_epoch=500, display_direction=True)
runner33.plot_results()

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),traning_per_epoch = 500:')
r34 = Robot2(g2,alpha=alpha, epsilon0=epsilon0, gamma=gamma)
r34.set_status(learning=True,testing=False)
runner34 = Runner(r34, g2)
runner34.run_training(epoch, training_per_epoch=500, display_direction=True)
runner34.plot_results()

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9:')
r35 = Robot2(g2,alpha=0.9, epsilon0=epsilon0, gamma=gamma)
r35.set_status(learning=True,testing=False)
runner35 = Runner(r35, g2)
runner35.run_training(epoch, display_direction=True)
runner35.plot_results() ## epsilon0 = 0

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),gamma = 0.99:')
r36 = Robot(g2,alpha=0.9, epsilon0=epsilon0, gamma=gamma)
r36.set_status(learning=True,testing=False)
runner36 = Runner(r36, g2)
runner36.run_training(epoch, display_direction=True)
runner36.plot_results() ## epsilon0 = 0

print('alpha = 0.9，gamma = 0.99:')
r37 = Robot(g2,alpha=0.9, epsilon0=epsilon0, gamma=0.99)
r37.set_status(learning=True,testing=False)
runner37 = Runner(r37, g2)
runner37.run_training(epoch, display_direction=True)
runner37.plot_results() ## epsilon0 = 0

print('alpha = 0.9，training_per_epoch = 500:')
r38 = Robot(g2,alpha=0.9, epsilon0=epsilon0, gamma=gamma)
r38.set_status(learning=True,testing=False)
runner38 = Runner(r38, g2)
runner38.run_training(epoch, training_per_epoch=500, display_direction=True)
runner38.plot_results() ## epsilon0 = 0

print('gamma = 0.99，training_per_epoch = 500:')
r39 = Robot(g2,alpha=alpha, epsilon0=epsilon0, gamma=0.99)
r39.set_status(learning=True,testing=False)
runner39 = Runner(r39, g2)
runner39.run_training(epoch, training_per_epoch=500, display_direction=True)
runner39.plot_results() ## epsilon0 = 0

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9, gamma = 0.99:')
r40 = Robot2(g2,alpha=0.9, epsilon0=epsilon0, gamma=0.99)
r40.set_status(learning=True,testing=False)
runner40 = Runner(r40, g2)
runner40.run_training(epoch, display_direction=True)
runner40.plot_results() ## epsilon0 = 0

print('alpha = 0.9, gamma = 0.99,training_per_epoch=500:')
r41 = Robot(g2,alpha=0.9, epsilon0=epsilon0, gamma=0.99)
r41.set_status(learning=True,testing=False)
runner41 = Runner(r41, g2)
runner41.run_training(epoch, training_per_epoch=500, display_direction=True)
runner41.plot_results() ## epsilon0 = 0

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),gamma = 0.99,training_per_epoch=500:')
r42 = Robot2(g2,alpha=alpha, epsilon0=epsilon0, gamma=0.99)
r42.set_status(learning=True,testing=False)
runner42 = Runner(r42, g2)
runner42.run_training(epoch, training_per_epoch=500, display_direction=True)
runner42.plot_results() ## epsilon0 = 0

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9,training_per_epoch=500:')
r43 = Robot2(g2,alpha=0.9, epsilon0=epsilon0, gamma=gamma)
r43.set_status(learning=True,testing=False)
runner43 = Runner(r43, g2)
runner43.run_training(epoch, training_per_epoch=500, display_direction=True)
runner43.plot_results() ## epsilon0 = 0

print('指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9, gamma = 0.99,training_per_epoch=500:')
r44 = Robot2(g2,alpha=0.9, epsilon0=epsilon0, gamma=0.99)
r44.set_status(learning=True,testing=False)
runner44 = Runner(r44, g2)
runner44.run_training(epoch, training_per_epoch=500, display_direction=True)
runner44.plot_results() ## epsilon0 = 0

对于g2地图:
指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)):

alpha = 0.9:

gamma = 0.99:

training_per_epoch = 500:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),traning_per_epoch = 500:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),gamma = 0.99:

alpha = 0.9，gamma = 0.99:

alpha = 0.9，training_per_epoch = 500:

gamma = 0.99，training_per_epoch = 500:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9, gamma = 0.99:

alpha = 0.9, gamma = 0.99,training_per_epoch=500:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),gamma = 0.99,training_per_epoch=500:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9,training_per_epoch=500:

指数级放大epsilon (epsilon = epsilon0/pow(t,0.63)),alpha = 0.9, gamma = 0.99,training_per_epoch=500:

# runner10.generate_movie(filename = "final0.mp4") # 你可以注释该行代码，加快运行速度，不过你就无法观察到视频了。
# runner1.generate_movie(filename = "final1.mp4") # 你可以注释该行代码，加快运行速度，不过你就无法观察到视频了。
# runner12.generate_movie(filename = "final2.mp4") # 你可以注释该行代码，加快运行速度，不过你就无法观察到视频了。

---

使用 runner.plot_results() 函数，能够打印机器人在训练过程中的一些参数信息。

• Success Times 代表机器人在训练过程中成功的累计次数，这应当是一个累积递增的图像。
• Accumulated Rewards 代表机器人在每次训练 epoch 中，获得的累积奖励的值，这应当是一个逐步递增的图像。
• Running Times per Epoch 代表在每次训练 epoch 中，小车训练的次数（到达终点就会停止该 epoch 转入下次训练），这应当是一个逐步递减的图像。

---

问题 8：使用 runner.plot_results() 输出训练结果，根据该结果对你的机器人进行分析。

• 指出你选用的参数如何，选用参数的原因。
• 建议你比较不同参数下机器人的训练的情况。
• 训练的结果是否满意，有何改进的计划。

(回答区)

对于epsilon（平衡exploration和exploitation, 试验设置见r0~r9)

• 对于简单情况（必经路径无陷阱，地图g）
• 对于简单问题，以epsilon在一定合理范围内均能找到最优解；
• 将epsilon直接放大10倍后，由于前10个epoch是完全随机的探索，很难找到终点，基本没有获得有效经验,同时进行更多的探索，导致其相对其它参数设置收敛较慢；

• epsilon的主要影响在于epoch后期的稳定性(曲线抖动)，epsilon越小，后期越稳定，epsilon越大，后期曲线抖动越明显；因此对于简单问题，epsilon可以设置较小，同时epoch可以设置较小，因为epoch再大后期也不会探索；如果计算资源充沛，可以将epsilon设置较大，但对于简单问题，意义不明显。

• 对于困难情况（必经路径有陷阱, 地图g1）

• 对于较小的epsilon，由于依赖过去的经验，不敢触碰困难（陷阱），即使偶尔找到终点，但不足以刷新状态值到质变水平，因此无法逾越陷阱找到解；

• 对于较大的epsilon，robot更具有探索精神，因此有更大机会逾越困难找到解，并收敛。

• 推论1：对于简单问题，可以设置较小epsilon以及较少的epoch，以高效快速得到解，随着问题难度增加，需要增大epsilon，提升探索的比例，提升找到解的可能性。（提升epsilon同时收敛速度降低，因此建议同步增大epoch）

• 人生感悟：勇气 敢于挑战困难，才有机会克服困难。

对于alpha（平衡过往epoch经验和当前经验, 试验设置见r10~r15)

• 对于简单情况（必经路径无陷阱，地图g）

• alpha在大范围的合理取值下均可以收敛到解，其主要影响收敛速度，alpha越小，收敛越慢；

• 对于困难情况（必经路径有陷阱，地图g1）

• alpha如果过小，代表停留在过去失败经验上过久，可能无法找到解，必须足够大，相信更现有的成功经验，才更有机会找到解；

• 推论2：对于简单或者困难问题，适当增加alpha都有好处，如果问题过于困难，无法求解，可以通过取更大的alpha值尝试求解。

• 人生感悟：求是 实事求是，灵活应变，不固守陈规。

对于gamma（每个epoch中未来奖励对现在动作的影响, 试验设置见r20~r25)

• 对于简单情况（必经路径无陷阱，地图g）

• gamma值的大小对求解影响不大

• 对于困难情况（必经路径有陷阱，地图g1）

• gamma必须足够大，才能帮忙克服中间陷阱对状态值的影响，找到解。

• 推论3：对于episode类型问题，gamma可以设置的更大，对于简单和困难的问题，都有一定的好处。

• 人生感悟：希望 领袖的关键在于看得见希望并传递希望。

对于training_per_epoch（每个epoch中确认失败重新开始前尝试的action的次数, 试验设置见r26~r27)

• 对于困难情况（必经路径有陷阱，地图g1）

• training_per_epoch的设置是为了避免陷入困境后钻死胡同降低效率，但对于困难问题，如果training_per_epoch设置过小，可能导致无法收敛。

• 推论4： 对于难以找到解困难问题，可以尝试通过适当增大training_per_epoch找到解。

• 人生感悟：坚毅 失败了从头再来没有问题，但如果太脆弱而轻易放弃，再多次的从头再来可能也没有意义。

推论局限性：

• 本试验场景内容相对简单（1、episode类问题，2、存在的解的数量不够丰富），因此相对“单纯”地显示alpha和gamma越大越好，但对于内容更加丰富的场景，alpha和gamma值调节方法可能需要更多验证。

对于特别困难的问题

• 单个要素的修正不足以保证结果收敛；
• 3个要素组合尝试中，gamma最关键，缺少优化的gamma，依然不能保证收敛；
• 但gamma不适合与epsilon单独配合，这意味这在无厘头尝试中过分传递了未来无厘头的结果给当前状态。

• 不要忘了，epoch是一切的基础，没有充分地迭代，一切参数配置无从谈起。

• 人生感悟：

• 多方面优秀素质组合才足以克服更大的困难；
• 希望是灯塔，失去了希望，再好的船，再多次的出海经验，依然迷失在夜色中；
• 盲目的希望（吹牛打鸡血）没有益处；
• 成功 = （不灭的希望+足够的坚毅+不墨守陈规+适度的冒险精神）* 重复跌倒爬起

---

问题 9： 请将如下的文件打包，提交文件给审阅者。

• robot.py
• robot_maze.ipynb
• 由 robot_maze.ipynb 导出的 robot_maze.html
• 个人补充：由于修改了Runner,因此提交修改Runner（85行增加self.robot.update_t()调用，每个epoch后,更新epsilon,原代码中是每个action(traning_per_epoch)后更新epsilon，与理论不符，导致epsilon过快收敛)；
• 个人补充：由于修改了Robot,因此提交修改Robot(132行增加了update_t()函数定义，原因同上）；
• 个人补充：由于修改了Robot2，Robot3,因此提交修改文件(52行修改了self.epsilon = self.epsilon0/pow(self.t,xx)，以改变epsilon随epoch增大的指数级减小速度）；